// adodb.h: interface for the adodb class.
//
//////////////////////////////////////////////////////////////////////
#ifndef __MSADO15_TLH_H__
#define __MSADO15_TLH_H__
#include <pshpack8.h>
//#pragma comment(lib,"ole32")
#include "comdef_msado.h"
#include "msado15_mgw.h"
namespace ADODB
{
struct  _Collection;
struct  _DynaCollection;
struct  _ADO;
struct  Properties;
struct  Property;
struct  Error;
struct  Errors;
struct  Command15;
struct  _Connection;
struct  Connection15;
struct  _Recordset;
struct  Recordset21;
struct  Recordset20;
struct  Recordset15;
struct  Fields;
struct  Fields20;
struct  Fields15;
struct  Field;
struct  Field20;
typedef long ADO_LONGPTR;
struct  _Parameter;
struct  Parameters;
struct  Command25;
struct  _Command;
struct  ConnectionEventsVt;
struct  RecordsetEventsVt;
struct  ConnectionEvents;
struct  RecordsetEvents;
struct  ADOConnectionConstruction15;
struct  ADOConnectionConstruction;
struct  Connection;
struct  _Record;
struct  Record;
struct  _Stream;
struct  Stream;
struct  ADORecordConstruction;
struct  ADOStreamConstruction;
struct  ADOCommandConstruction;
struct  Command;
struct  Recordset;
struct  ADORecordsetConstruction;
struct  Field15;
struct  Parameter;
//
//enum
//
enum CursorTypeEnum
{
    adOpenUnspecified = -1,
    adOpenForwardOnly = 0,
    adOpenKeyset = 1,
    adOpenDynamic = 2,
    adOpenStatic = 3
};

enum CursorOptionEnum
{
    adHoldRecords = 256,
    adMovePrevious = 512,
    adAddNew = 16778240,
    adDelete = 16779264,
    adUpdate = 16809984,
    adBookmark = 8192,
    adApproxPosition = 16384,
    adUpdateBatch = 65536,
    adResync = 131072,
    adNotify = 262144,
    adFind = 524288,
    adSeek = 4194304,
    adIndex = 8388608
};

enum LockTypeEnum
{
    adLockUnspecified = -1,
    adLockReadOnly = 1,
    adLockPessimistic = 2,
    adLockOptimistic = 3,
    adLockBatchOptimistic = 4
};

enum ExecuteOptionEnum
{
    adOptionUnspecified = -1,
    adAsyncExecute = 16,
    adAsyncFetch = 32,
    adAsyncFetchNonBlocking = 64,
    adExecuteNoRecords = 128,
    adExecuteStream = 1024,
    adExecuteRecord = 2048
};

enum ConnectOptionEnum
{
    adConnectUnspecified = -1,
    adAsyncConnect = 16
};

enum ObjectStateEnum
{
    adStateClosed = 0,
    adStateOpen = 1,
    adStateConnecting = 2,
    adStateExecuting = 4,
    adStateFetching = 8
};

enum CursorLocationEnum
{
    adUseNone = 1,
    adUseServer = 2,
    adUseClient = 3,
    adUseClientBatch = 3
};

enum DataTypeEnum
{
    adEmpty = 0,
    adTinyInt = 16,
    adSmallInt = 2,
    adInteger = 3,
    adBigInt = 20,
    adUnsignedTinyInt = 17,
    adUnsignedSmallInt = 18,
    adUnsignedInt = 19,
    adUnsignedBigInt = 21,
    adSingle = 4,
    adDouble = 5,
    adCurrency = 6,
    adDecimal = 14,
    adNumeric = 131,
    adBoolean = 11,
    adError = 10,
    adUserDefined = 132,
    adVariant = 12,
    adIDispatch = 9,
    adIUnknown = 13,
    adGUID = 72,
    adDate = 7,
    adDBDate = 133,
    adDBTime = 134,
    adDBTimeStamp = 135,
    adBSTR = 8,
    adChar = 129,
    adVarChar = 200,
    adLongVarChar = 201,
    adWChar = 130,
    adVarWChar = 202,
    adLongVarWChar = 203,
    adBinary = 128,
    adVarBinary = 204,
    adLongVarBinary = 205,
    adChapter = 136,
    adFileTime = 64,
    adPropVariant = 138,
    adVarNumeric = 139,
    adArray = 8192
};

enum FieldAttributeEnum
{
    adFldUnspecified = -1,
    adFldMayDefer = 2,
    adFldUpdatable = 4,
    adFldUnknownUpdatable = 8,
    adFldFixed = 16,
    adFldIsNullable = 32,
    adFldMayBeNull = 64,
    adFldLong = 128,
    adFldRowID = 256,
    adFldRowVersion = 512,
    adFldCacheDeferred = 4096,
    adFldIsChapter = 8192,
    adFldNegativeScale = 16384,
    adFldKeyColumn = 32768,
    adFldIsRowURL = 65536,
    adFldIsDefaultStream = 131072,
    adFldIsCollection = 262144
};

enum EditModeEnum
{
    adEditNone = 0,
    adEditInProgress = 1,
    adEditAdd = 2,
    adEditDelete = 4
};

enum RecordStatusEnum
{
    adRecOK = 0,
    adRecNew = 1,
    adRecModified = 2,
    adRecDeleted = 4,
    adRecUnmodified = 8,
    adRecInvalid = 16,
    adRecMultipleChanges = 64,
    adRecPendingChanges = 128,
    adRecCanceled = 256,
    adRecCantRelease = 1024,
    adRecConcurrencyViolation = 2048,
    adRecIntegrityViolation = 4096,
    adRecMaxChangesExceeded = 8192,
    adRecObjectOpen = 16384,
    adRecOutOfMemory = 32768,
    adRecPermissionDenied = 65536,
    adRecSchemaViolation = 131072,
    adRecDBDeleted = 262144
};

enum GetRowsOptionEnum
{
    adGetRowsRest = -1
};

enum PositionEnum
{
    adPosUnknown = -1,
    adPosBOF = -2,
    adPosEOF = -3
};

enum BookmarkEnum
{
    adBookmarkCurrent = 0,
    adBookmarkFirst = 1,
    adBookmarkLast = 2
};

enum MarshalOptionsEnum
{
    adMarshalAll = 0,
    adMarshalModifiedOnly = 1
};

enum AffectEnum
{
    adAffectCurrent = 1,
    adAffectGroup = 2,
    adAffectAll = 3,
    adAffectAllChapters = 4
};

enum ResyncEnum
{
    adResyncUnderlyingValues = 1,
    adResyncAllValues = 2
};

enum CompareEnum
{
    adCompareLessThan = 0,
    adCompareEqual = 1,
    adCompareGreaterThan = 2,
    adCompareNotEqual = 3,
    adCompareNotComparable = 4
};

enum FilterGroupEnum
{
    adFilterNone = 0,
    adFilterPendingRecords = 1,
    adFilterAffectedRecords = 2,
    adFilterFetchedRecords = 3,
    adFilterPredicate = 4,
    adFilterConflictingRecords = 5
};

enum SearchDirectionEnum
{
    adSearchForward = 1,
    adSearchBackward = -1
};

enum PersistFormatEnum
{
    adPersistADTG = 0,
    adPersistXML = 1
};

enum StringFormatEnum
{
    adClipString = 2
};

enum ConnectPromptEnum
{
    adPromptAlways = 1,
    adPromptComplete = 2,
    adPromptCompleteRequired = 3,
    adPromptNever = 4
};

enum ConnectModeEnum
{
    adModeUnknown = 0,
    adModeRead = 1,
    adModeWrite = 2,
    adModeReadWrite = 3,
    adModeShareDenyRead = 4,
    adModeShareDenyWrite = 8,
    adModeShareExclusive = 12,
    adModeShareDenyNone = 16,
    adModeRecursive = 4194304
};

enum RecordCreateOptionsEnum
{
    adCreateCollection = 8192,
    adCreateStructDoc = -2147483648,
    adCreateNonCollection = 0,
    adOpenIfExists = 33554432,
    adCreateOverwrite = 67108864,
    adFailIfNotExists = -1
};

enum RecordOpenOptionsEnum
{
    adOpenRecordUnspecified = -1,
    adOpenSource = 8388608,
    adOpenOutput = 8388608,
    adOpenAsync = 4096,
    adDelayFetchStream = 16384,
    adDelayFetchFields = 32768,
    adOpenExecuteCommand = 65536
};

enum IsolationLevelEnum
{
    adXactUnspecified = -1,
    adXactChaos = 16,
    adXactReadUncommitted = 256,
    adXactBrowse = 256,
    adXactCursorStability = 4096,
    adXactReadCommitted = 4096,
    adXactRepeatableRead = 65536,
    adXactSerializable = 1048576,
    adXactIsolated = 1048576
};

enum XactAttributeEnum
{
    adXactCommitRetaining = 131072,
    adXactAbortRetaining = 262144,
    adXactAsyncPhaseOne = 524288,
    adXactSyncPhaseOne = 1048576
};

enum PropertyAttributesEnum
{
    adPropNotSupported = 0,
    adPropRequired = 1,
    adPropOptional = 2,
    adPropRead = 512,
    adPropWrite = 1024
};

enum ErrorValueEnum
{
    adErrProviderFailed = 3000,
    adErrInvalidArgument = 3001,
    adErrOpeningFile = 3002,
    adErrReadFile = 3003,
    adErrWriteFile = 3004,
    adErrNoCurrentRecord = 3021,
    adErrIllegalOperation = 3219,
    adErrCantChangeProvider = 3220,
    adErrInTransaction = 3246,
    adErrFeatureNotAvailable = 3251,
    adErrItemNotFound = 3265,
    adErrObjectInCollection = 3367,
    adErrObjectNotSet = 3420,
    adErrDataConversion = 3421,
    adErrObjectClosed = 3704,
    adErrObjectOpen = 3705,
    adErrProviderNotFound = 3706,
    adErrBoundToCommand = 3707,
    adErrInvalidParamInfo = 3708,
    adErrInvalidConnection = 3709,
    adErrNotReentrant = 3710,
    adErrStillExecuting = 3711,
    adErrOperationCancelled = 3712,
    adErrStillConnecting = 3713,
    adErrInvalidTransaction = 3714,
    adErrNotExecuting = 3715,
    adErrUnsafeOperation = 3716,
    adwrnSecurityDialog = 3717,
    adwrnSecurityDialogHeader = 3718,
    adErrIntegrityViolation = 3719,
    adErrPermissionDenied = 3720,
    adErrDataOverflow = 3721,
    adErrSchemaViolation = 3722,
    adErrSignMismatch = 3723,
    adErrCantConvertvalue = 3724,
    adErrCantCreate = 3725,
    adErrColumnNotOnThisRow = 3726,
    adErrURLDoesNotExist = 3727,
    adErrTreePermissionDenied = 3728,
    adErrInvalidURL = 3729,
    adErrResourceLocked = 3730,
    adErrResourceExists = 3731,
    adErrCannotComplete = 3732,
    adErrVolumeNotFound = 3733,
    adErrOutOfSpace = 3734,
    adErrResourceOutOfScope = 3735,
    adErrUnavailable = 3736,
    adErrURLNamedRowDoesNotExist = 3737,
    adErrDelResOutOfScope = 3738,
    adErrPropInvalidColumn = 3739,
    adErrPropInvalidOption = 3740,
    adErrPropInvalidValue = 3741,
    adErrPropConflicting = 3742,
    adErrPropNotAllSettable = 3743,
    adErrPropNotSet = 3744,
    adErrPropNotSettable = 3745,
    adErrPropNotSupported = 3746,
    adErrCatalogNotSet = 3747,
    adErrCantChangeConnection = 3748,
    adErrFieldsUpdateFailed = 3749,
    adErrDenyNotSupported = 3750,
    adErrDenyTypeNotSupported = 3751,
    adErrProviderNotSpecified = 3753,
    adErrConnectionStringTooLong = 3754
};

enum ParameterAttributesEnum
{
    adParamSigned = 16,
    adParamNullable = 64,
    adParamLong = 128
};

enum ParameterDirectionEnum
{
    adParamUnknown = 0,
    adParamInput = 1,
    adParamOutput = 2,
    adParamInputOutput = 3,
    adParamReturnValue = 4
};

enum CommandTypeEnum
{
    adCmdUnspecified = -1,
    adCmdUnknown = 8,
    adCmdText = 1,
    adCmdTable = 2,
    adCmdStoredProc = 4,
    adCmdFile = 256,
    adCmdTableDirect = 512
};

enum EventStatusEnum
{
    adStatusOK = 1,
    adStatusErrorsOccurred = 2,
    adStatusCantDeny = 3,
    adStatusCancel = 4,
    adStatusUnwantedEvent = 5
};

enum EventReasonEnum
{
    adRsnAddNew = 1,
    adRsnDelete = 2,
    adRsnUpdate = 3,
    adRsnUndoUpdate = 4,
    adRsnUndoAddNew = 5,
    adRsnUndoDelete = 6,
    adRsnRequery = 7,
    adRsnResynch = 8,
    adRsnClose = 9,
    adRsnMove = 10,
    adRsnFirstChange = 11,
    adRsnMoveFirst = 12,
    adRsnMoveNext = 13,
    adRsnMovePrevious = 14,
    adRsnMoveLast = 15
};

enum SchemaEnum
{
    adSchemaProviderSpecific = -1,
    adSchemaAsserts = 0,
    adSchemaCatalogs = 1,
    adSchemaCharacterSets = 2,
    adSchemaCollations = 3,
    adSchemaColumns = 4,
    adSchemaCheckConstraints = 5,
    adSchemaConstraintColumnUsage = 6,
    adSchemaConstraintTableUsage = 7,
    adSchemaKeyColumnUsage = 8,
    adSchemaReferentialContraints = 9,
    adSchemaReferentialConstraints = 9,
    adSchemaTableConstraints = 10,
    adSchemaColumnsDomainUsage = 11,
    adSchemaIndexes = 12,
    adSchemaColumnPrivileges = 13,
    adSchemaTablePrivileges = 14,
    adSchemaUsagePrivileges = 15,
    adSchemaProcedures = 16,
    adSchemaSchemata = 17,
    adSchemaSQLLanguages = 18,
    adSchemaStatistics = 19,
    adSchemaTables = 20,
    adSchemaTranslations = 21,
    adSchemaProviderTypes = 22,
    adSchemaViews = 23,
    adSchemaViewColumnUsage = 24,
    adSchemaViewTableUsage = 25,
    adSchemaProcedureParameters = 26,
    adSchemaForeignKeys = 27,
    adSchemaPrimaryKeys = 28,
    adSchemaProcedureColumns = 29,
    adSchemaDBInfoKeywords = 30,
    adSchemaDBInfoLiterals = 31,
    adSchemaCubes = 32,
    adSchemaDimensions = 33,
    adSchemaHierarchies = 34,
    adSchemaLevels = 35,
    adSchemaMeasures = 36,
    adSchemaProperties = 37,
    adSchemaMembers = 38,
    adSchemaTrustees = 39,
    adSchemaFunctions = 40,
    adSchemaActions = 41,
    adSchemaCommands = 42,
    adSchemaSets = 43
};

enum FieldStatusEnum
{
    adFieldOK = 0,
    adFieldCantConvertValue = 2,
    adFieldIsNull = 3,
    adFieldTruncated = 4,
    adFieldSignMismatch = 5,
    adFieldDataOverflow = 6,
    adFieldCantCreate = 7,
    adFieldUnavailable = 8,
    adFieldPermissionDenied = 9,
    adFieldIntegrityViolation = 10,
    adFieldSchemaViolation = 11,
    adFieldBadStatus = 12,
    adFieldDefault = 13,
    adFieldIgnore = 15,
    adFieldDoesNotExist = 16,
    adFieldInvalidURL = 17,
    adFieldResourceLocked = 18,
    adFieldResourceExists = 19,
    adFieldCannotComplete = 20,
    adFieldVolumeNotFound = 21,
    adFieldOutOfSpace = 22,
    adFieldCannotDeleteSource = 23,
    adFieldReadOnly = 24,
    adFieldResourceOutOfScope = 25,
    adFieldAlreadyExists = 26,
    adFieldPendingInsert = 65536,
    adFieldPendingDelete = 131072,
    adFieldPendingChange = 262144,
    adFieldPendingUnknown = 524288,
    adFieldPendingUnknownDelete = 1048576
};

enum SeekEnum
{
    adSeekFirstEQ = 1,
    adSeekLastEQ = 2,
    adSeekAfterEQ = 4,
    adSeekAfter = 8,
    adSeekBeforeEQ = 16,
    adSeekBefore = 32
};

enum ADCPROP_UPDATECRITERIA_ENUM
{
    adCriteriaKey = 0,
    adCriteriaAllCols = 1,
    adCriteriaUpdCols = 2,
    adCriteriaTimeStamp = 3
};

enum ADCPROP_ASYNCTHREADPRIORITY_ENUM
{
    adPriorityLowest = 1,
    adPriorityBelowNormal = 2,
    adPriorityNormal = 3,
    adPriorityAboveNormal = 4,
    adPriorityHighest = 5
};

enum ADCPROP_AUTORECALC_ENUM
{
    adRecalcUpFront = 0,
    adRecalcAlways = 1
};

enum ADCPROP_UPDATERESYNC_ENUM
{
    adResyncNone = 0,
    adResyncAutoIncrement = 1,
    adResyncConflicts = 2,
    adResyncUpdates = 4,
    adResyncInserts = 8,
    adResyncAll = 15
};

enum MoveRecordOptionsEnum
{
    adMoveUnspecified = -1,
    adMoveOverWrite = 1,
    adMoveDontUpdateLinks = 2,
    adMoveAllowEmulation = 4
};

enum CopyRecordOptionsEnum
{
    adCopyUnspecified = -1,
    adCopyOverWrite = 1,
    adCopyAllowEmulation = 4,
    adCopyNonRecursive = 2
};

enum StreamTypeEnum
{
    adTypeBinary = 1,
    adTypeText = 2
};

enum LineSeparatorEnum
{
    adLF = 10,
    adCR = 13,
    adCRLF = -1
};

enum StreamOpenOptionsEnum
{
    adOpenStreamUnspecified = -1,
    adOpenStreamAsync = 1,
    adOpenStreamFromRecord = 4
};

enum StreamWriteEnum
{
    adWriteChar = 0,
    adWriteLine = 1,
    stWriteChar = 0,
    stWriteLine = 1
};

enum SaveOptionsEnum
{
    adSaveCreateNotExist = 1,
    adSaveCreateOverWrite = 2
};

enum FieldEnum
{
    adDefaultStream = -1,
    adRecordURL = -2
};

enum StreamReadEnum
{
    adReadAll = -1,
    adReadLine = -2
};

enum RecordTypeEnum
{
    adSimpleRecord = 0,
    adCollectionRecord = 1,
    adStructDoc = 2
};
typedef enum PositionEnum PositionEnum_Param;
typedef enum SearchDirectionEnum SearchDirection;

struct _Collection: public IDispatch
{
	long GetCount();
	IUnknownPtr _NewEnum();
	HRESULT Refresh();
	virtual HRESULT __stdcall get_Count(
	    long * c) = 0;
	virtual HRESULT __stdcall raw__NewEnum(
	    IUnknown ** ppvObject) = 0;
	virtual HRESULT __stdcall raw_Refresh() = 0;
};
struct _DynaCollection: public _Collection
{
	HRESULT Append(
	    IDispatch * Object);
	HRESULT Delete(
	    const _variant_t & Index);
	virtual HRESULT __stdcall raw_Append(
	    IDispatch * Object) = 0;
	virtual HRESULT __stdcall raw_Delete(
	    VARIANT Index) = 0;
};
struct _ADO: public IDispatch
{
	PropertiesPtr GetProperties();
	virtual HRESULT __stdcall get_Properties(
	    struct Properties ** ppvObject) = 0;
};
struct Properties: public _Collection
{
	PropertyPtr GetItem(
	    const _variant_t & Index);
	virtual HRESULT __stdcall get_Item(
	    VARIANT Index,
	    struct Property ** ppvObject) = 0;
};
struct Property: public IDispatch
{
	_variant_t GetValue();
	void PutValue(
	    const _variant_t & pval);
	_bstr_t GetName();
	enum DataTypeEnum GetType();
	long GetAttributes();
	void PutAttributes(
	    long plAttributes);
	virtual HRESULT __stdcall get_Value(
	    VARIANT * pval) = 0;
	virtual HRESULT __stdcall put_Value(
	    VARIANT pval) = 0;
	virtual HRESULT __stdcall get_Name(
	    BSTR * pbstr) = 0;
	virtual HRESULT __stdcall get_Type(
	    enum DataTypeEnum * ptype) = 0;
	virtual HRESULT __stdcall get_Attributes(
	    long * plAttributes) = 0;
	virtual HRESULT __stdcall put_Attributes(
	    long plAttributes) = 0;
};
struct Error: public IDispatch
{
	long GetNumber();
	_bstr_t GetSource();
	_bstr_t GetDescription();
	_bstr_t GetHelpFile();
	long GetHelpContext();
	_bstr_t GetSQLState();
	long GetNativeError();
	virtual HRESULT __stdcall get_Number(
	    long * pl) = 0;
	virtual HRESULT __stdcall get_Source(
	    BSTR * pbstr) = 0;
	virtual HRESULT __stdcall get_Description(
	    BSTR * pbstr) = 0;
	virtual HRESULT __stdcall get_HelpFile(
	    BSTR * pbstr) = 0;
	virtual HRESULT __stdcall get_HelpContext(
	    long * pl) = 0;
	virtual HRESULT __stdcall get_SQLState(
	    BSTR * pbstr) = 0;
	virtual HRESULT __stdcall get_NativeError(
	    long * pl) = 0;
};
struct Errors: public _Collection
{
	ErrorPtr GetItem(
	    const _variant_t & Index);
	HRESULT Clear();
	virtual HRESULT __stdcall get_Item(
	    VARIANT Index,
	    struct Error ** ppvObject) = 0;
	virtual HRESULT __stdcall raw_Clear() = 0;
};
struct Command15: public _ADO
{
	_ConnectionPtr GetActiveConnection();
	void PutRefActiveConnection(
	    struct _Connection * ppvObject);
	void PutActiveConnection(
	    const _variant_t & ppvObject);
	_bstr_t GetCommandText();
	void PutCommandText(
	    _bstr_t pbstr);
	long GetCommandTimeout();
	void PutCommandTimeout(
	    long pl);
	VARIANT_BOOL GetPrepared();
	void PutPrepared(
	    VARIANT_BOOL pfPrepared);
	_RecordsetPtr Execute(
	    VARIANT * RecordsAffected,
	    VARIANT * Parameters,
	    long Options);
	_ParameterPtr CreateParameter(
	    _bstr_t Name,
	    enum DataTypeEnum Type,
	    enum ParameterDirectionEnum Direction,
	    ADO_LONGPTR Size,
	    const _variant_t & Value = vtMissing);
	ParametersPtr GetParameters();
	void PutCommandType(
	    enum CommandTypeEnum plCmdType);
	enum CommandTypeEnum GetCommandType();
	_bstr_t GetName();
	void PutName(
	    _bstr_t pbstrName);
	virtual HRESULT __stdcall get_ActiveConnection(
	    struct _Connection ** ppvObject) = 0;
	virtual HRESULT __stdcall putref_ActiveConnection(
	    struct _Connection * ppvObject) = 0;
	virtual HRESULT __stdcall put_ActiveConnection(
	    VARIANT ppvObject) = 0;
	virtual HRESULT __stdcall get_CommandText(
	    BSTR * pbstr) = 0;
	virtual HRESULT __stdcall put_CommandText(
	    BSTR pbstr) = 0;
	virtual HRESULT __stdcall get_CommandTimeout(
	    long * pl) = 0;
	virtual HRESULT __stdcall put_CommandTimeout(
	    long pl) = 0;
	virtual HRESULT __stdcall get_Prepared(
	    VARIANT_BOOL * pfPrepared) = 0;
	virtual HRESULT __stdcall put_Prepared(
	    VARIANT_BOOL pfPrepared) = 0;
	virtual HRESULT __stdcall raw_Execute(
	    VARIANT * RecordsAffected,
	    VARIANT * Parameters,
	    long Options,
	    struct _Recordset ** ppiRs) = 0;
	virtual HRESULT __stdcall raw_CreateParameter(
	    BSTR Name,
	    enum DataTypeEnum Type,
	    enum ParameterDirectionEnum Direction,
	    ADO_LONGPTR Size,
	    VARIANT Value,
	    struct _Parameter ** ppiprm) = 0;
	virtual HRESULT __stdcall get_Parameters(
	    struct Parameters ** ppvObject) = 0;
	virtual HRESULT __stdcall put_CommandType(
	    enum CommandTypeEnum plCmdType) = 0;
	virtual HRESULT __stdcall get_CommandType(
	    enum CommandTypeEnum * plCmdType) = 0;
	virtual HRESULT __stdcall get_Name(
	    BSTR * pbstrName) = 0;
	virtual HRESULT __stdcall put_Name(
	    BSTR pbstrName) = 0;
};
struct Connection15: public _ADO
{
	_bstr_t GetConnectionString();
	void PutConnectionString(
	    _bstr_t pbstr);
	long GetCommandTimeout();
	void PutCommandTimeout(
	    long plTimeout);
	long GetConnectionTimeout();
	void PutConnectionTimeout(
	    long plTimeout);
	_bstr_t GetVersion();
	HRESULT Close();
	_RecordsetPtr Execute(
	    _bstr_t CommandText,
	    VARIANT * RecordsAffected,
	    long Options);
	long BeginTrans();
	HRESULT CommitTrans();
	HRESULT RollbackTrans();
	HRESULT Open(
	    _bstr_t ConnectionString,
	    _bstr_t UserID,
	    _bstr_t Password,
	    long Options);
	ErrorsPtr GetErrors();
	_bstr_t GetDefaultDatabase();
	void PutDefaultDatabase(
	    _bstr_t pbstr);
	enum IsolationLevelEnum GetIsolationLevel();
	void PutIsolationLevel(
	    enum IsolationLevelEnum Level);
	long GetAttributes();
	void PutAttributes(
	    long plAttr);
	enum CursorLocationEnum GetCursorLocation();
	void PutCursorLocation(
	    enum CursorLocationEnum plCursorLoc);
	enum ConnectModeEnum GetMode();
	void PutMode(
	    enum ConnectModeEnum plMode);
	_bstr_t GetProvider();
	void PutProvider(
	    _bstr_t pbstr);
	long GetState();
	_RecordsetPtr OpenSchema(
	    enum SchemaEnum Schema,
	    const _variant_t & Restrictions = vtMissing,
	    const _variant_t & SchemaID = vtMissing);
	virtual HRESULT __stdcall get_ConnectionString(
	    BSTR * pbstr) = 0;
	virtual HRESULT __stdcall put_ConnectionString(
	    BSTR pbstr) = 0;
	virtual HRESULT __stdcall get_CommandTimeout(
	    long * plTimeout) = 0;
	virtual HRESULT __stdcall put_CommandTimeout(
	    long plTimeout) = 0;
	virtual HRESULT __stdcall get_ConnectionTimeout(
	    long * plTimeout) = 0;
	virtual HRESULT __stdcall put_ConnectionTimeout(
	    long plTimeout) = 0;
	virtual HRESULT __stdcall get_Version(
	    BSTR * pbstr) = 0;
	virtual HRESULT __stdcall raw_Close() = 0;
	virtual HRESULT __stdcall raw_Execute(
	    BSTR CommandText,
	    VARIANT * RecordsAffected,
	    long Options,
	    struct _Recordset ** ppiRset) = 0;
	virtual HRESULT __stdcall raw_BeginTrans(
	    long * TransactionLevel) = 0;
	virtual HRESULT __stdcall raw_CommitTrans() = 0;
	virtual HRESULT __stdcall raw_RollbackTrans() = 0;
	virtual HRESULT __stdcall raw_Open(
	    BSTR ConnectionString,
	    BSTR UserID,
	    BSTR Password,
	    long Options) = 0;
	virtual HRESULT __stdcall get_Errors(
	    struct Errors ** ppvObject) = 0;
	virtual HRESULT __stdcall get_DefaultDatabase(
	    BSTR * pbstr) = 0;
	virtual HRESULT __stdcall put_DefaultDatabase(
	    BSTR pbstr) = 0;
	virtual HRESULT __stdcall get_IsolationLevel(
	    enum IsolationLevelEnum * Level) = 0;
	virtual HRESULT __stdcall put_IsolationLevel(
	    enum IsolationLevelEnum Level) = 0;
	virtual HRESULT __stdcall get_Attributes(
	    long * plAttr) = 0;
	virtual HRESULT __stdcall put_Attributes(
	    long plAttr) = 0;
	virtual HRESULT __stdcall get_CursorLocation(
	    enum CursorLocationEnum * plCursorLoc) = 0;
	virtual HRESULT __stdcall put_CursorLocation(
	    enum CursorLocationEnum plCursorLoc) = 0;
	virtual HRESULT __stdcall get_Mode(
	    enum ConnectModeEnum * plMode) = 0;
	virtual HRESULT __stdcall put_Mode(
	    enum ConnectModeEnum plMode) = 0;
	virtual HRESULT __stdcall get_Provider(
	    BSTR * pbstr) = 0;
	virtual HRESULT __stdcall put_Provider(
	    BSTR pbstr) = 0;
	virtual HRESULT __stdcall get_State(
	    long * plObjState) = 0;
	virtual HRESULT __stdcall raw_OpenSchema(
	    enum SchemaEnum Schema,
	    VARIANT Restrictions,
	    VARIANT SchemaID,
	    struct _Recordset ** pprset) = 0;
};
struct _Connection: public Connection15
{
	HRESULT Cancel();
	virtual HRESULT __stdcall raw_Cancel() = 0;
};
struct Recordset15: public _ADO
{
	PositionEnum_Param GetAbsolutePosition();
	void PutAbsolutePosition(
	    PositionEnum_Param pl);
	void PutRefActiveConnection(
	    IDispatch * pvar);
	void PutActiveConnection(
	    const _variant_t & pvar);
	_variant_t GetActiveConnection();
	VARIANT_BOOL GetBOF();
	_variant_t GetBookmark();
	void PutBookmark(
	    const _variant_t & pvBookmark);
	long GetCacheSize();
	void PutCacheSize(
	    long pl);
	enum CursorTypeEnum GetCursorType();
	void PutCursorType(
	    enum CursorTypeEnum plCursorType);
	VARIANT_BOOL GetadoEOF();
	FieldsPtr GetFields();
	enum LockTypeEnum GetLockType();
	void PutLockType(
	    enum LockTypeEnum plLockType);
	ADO_LONGPTR GetMaxRecords();
	void PutMaxRecords(
	    ADO_LONGPTR plMaxRecords);
	ADO_LONGPTR GetRecordCount();
	void PutRefSource(
	    IDispatch * pvSource);
	void PutSource(
	    _bstr_t pvSource);
	_variant_t GetSource();
	HRESULT AddNew(
	    const _variant_t & FieldList = vtMissing,
	    const _variant_t & Values = vtMissing);
	HRESULT CancelUpdate();
	HRESULT Close();
	HRESULT Delete(
	    enum AffectEnum AffectRecords);
	_variant_t GetRows(
	    long Rows,
	    const _variant_t & Start = vtMissing,
	    const _variant_t & Fields = vtMissing);
	HRESULT Move(
	    ADO_LONGPTR NumRecords,
	    const _variant_t & Start = vtMissing);
	HRESULT MoveNext();
	HRESULT MovePrevious();
	HRESULT MoveFirst();
	HRESULT MoveLast();
	HRESULT Open(
	    const _variant_t & Source,
	    const _variant_t & ActiveConnection,
	    enum CursorTypeEnum CursorType,
	    enum LockTypeEnum LockType,
	    long Options);
	HRESULT Requery(
	    long Options);
	HRESULT _xResync(
	    enum AffectEnum AffectRecords);
	HRESULT Update(
	    const _variant_t & Fields = vtMissing,
	    const _variant_t & Values = vtMissing);
	PositionEnum_Param GetAbsolutePage();
	void PutAbsolutePage(
	    PositionEnum_Param pl);
	enum EditModeEnum GetEditMode();
	_variant_t GetFilter();
	void PutFilter(
	    const _variant_t & Criteria);
	ADO_LONGPTR GetPageCount();
	long GetPageSize();
	void PutPageSize(
	    long pl);
	_bstr_t GetSort();
	void PutSort(
	    _bstr_t Criteria);
	long GetStatus();
	long GetState();
	_RecordsetPtr _xClone();
	HRESULT UpdateBatch(
	    enum AffectEnum AffectRecords);
	HRESULT CancelBatch(
	    enum AffectEnum AffectRecords);
	enum CursorLocationEnum GetCursorLocation();
	void PutCursorLocation(
	    enum CursorLocationEnum plCursorLoc);
	_RecordsetPtr NextRecordset(
	    VARIANT * RecordsAffected);
	VARIANT_BOOL Supports(
	    enum CursorOptionEnum CursorOptions);
	_variant_t GetCollect(
	    const _variant_t & Index);
	void PutCollect(
	    const _variant_t & Index,
	    const _variant_t & pvar);
	enum MarshalOptionsEnum GetMarshalOptions();
	void PutMarshalOptions(
	    enum MarshalOptionsEnum peMarshal);
	HRESULT Find(
	    _bstr_t Criteria,
	    ADO_LONGPTR SkipRecords,
	    enum SearchDirectionEnum SearchDirection,
	    const _variant_t & Start = vtMissing);
	virtual HRESULT __stdcall get_AbsolutePosition(
	    PositionEnum_Param * pl) = 0;
	virtual HRESULT __stdcall put_AbsolutePosition(
	    PositionEnum_Param pl) = 0;
	virtual HRESULT __stdcall putref_ActiveConnection(
	    IDispatch * pvar) = 0;
	virtual HRESULT __stdcall put_ActiveConnection(
	    VARIANT pvar) = 0;
	virtual HRESULT __stdcall get_ActiveConnection(
	    VARIANT * pvar) = 0;
	virtual HRESULT __stdcall get_BOF(
	    VARIANT_BOOL * pb) = 0;
	virtual HRESULT __stdcall get_Bookmark(
	    VARIANT * pvBookmark) = 0;
	virtual HRESULT __stdcall put_Bookmark(
	    VARIANT pvBookmark) = 0;
	virtual HRESULT __stdcall get_CacheSize(
	    long * pl) = 0;
	virtual HRESULT __stdcall put_CacheSize(
	    long pl) = 0;
	virtual HRESULT __stdcall get_CursorType(
	    enum CursorTypeEnum * plCursorType) = 0;
	virtual HRESULT __stdcall put_CursorType(
	    enum CursorTypeEnum plCursorType) = 0;
	virtual HRESULT __stdcall get_adoEOF(
	    VARIANT_BOOL * pb) = 0;
	virtual HRESULT __stdcall get_Fields(
	    struct Fields ** ppvObject) = 0;
	virtual HRESULT __stdcall get_LockType(
	    enum LockTypeEnum * plLockType) = 0;
	virtual HRESULT __stdcall put_LockType(
	    enum LockTypeEnum plLockType) = 0;
	virtual HRESULT __stdcall get_MaxRecords(
	    ADO_LONGPTR * plMaxRecords) = 0;
	virtual HRESULT __stdcall put_MaxRecords(
	    ADO_LONGPTR plMaxRecords) = 0;
	virtual HRESULT __stdcall get_RecordCount(
	    ADO_LONGPTR * pl) = 0;
	virtual HRESULT __stdcall putref_Source(
	    IDispatch * pvSource) = 0;
	virtual HRESULT __stdcall put_Source(
	    BSTR pvSource) = 0;
	virtual HRESULT __stdcall get_Source(
	    VARIANT * pvSource) = 0;
	virtual HRESULT __stdcall raw_AddNew(
	    VARIANT FieldList = vtMissing,
	    VARIANT Values = vtMissing) = 0;
	virtual HRESULT __stdcall raw_CancelUpdate() = 0;
	virtual HRESULT __stdcall raw_Close() = 0;
	virtual HRESULT __stdcall raw_Delete(
	    enum AffectEnum AffectRecords) = 0;
	virtual HRESULT __stdcall raw_GetRows(
	    long Rows,
	    VARIANT Start,
	    VARIANT Fields,
	    VARIANT * pvar) = 0;
	virtual HRESULT __stdcall raw_Move(
	    ADO_LONGPTR NumRecords,
	    VARIANT Start = vtMissing) = 0;
	virtual HRESULT __stdcall raw_MoveNext() = 0;
	virtual HRESULT __stdcall raw_MovePrevious() = 0;
	virtual HRESULT __stdcall raw_MoveFirst() = 0;
	virtual HRESULT __stdcall raw_MoveLast() = 0;
	virtual HRESULT __stdcall raw_Open(
	    VARIANT Source,
	    VARIANT ActiveConnection,
	    enum CursorTypeEnum CursorType,
	    enum LockTypeEnum LockType,
	    long Options) = 0;
	virtual HRESULT __stdcall raw_Requery(
	    long Options) = 0;
	virtual HRESULT __stdcall raw__xResync(
	    enum AffectEnum AffectRecords) = 0;
	virtual HRESULT __stdcall raw_Update(
	    VARIANT Fields = vtMissing,
	    VARIANT Values = vtMissing) = 0;
	virtual HRESULT __stdcall get_AbsolutePage(
	    PositionEnum_Param * pl) = 0;
	virtual HRESULT __stdcall put_AbsolutePage(
	    PositionEnum_Param pl) = 0;
	virtual HRESULT __stdcall get_EditMode(
	    enum EditModeEnum * pl) = 0;
	virtual HRESULT __stdcall get_Filter(
	    VARIANT * Criteria) = 0;
	virtual HRESULT __stdcall put_Filter(
	    VARIANT Criteria) = 0;
	virtual HRESULT __stdcall get_PageCount(
	    ADO_LONGPTR * pl) = 0;
	virtual HRESULT __stdcall get_PageSize(
	    long * pl) = 0;
	virtual HRESULT __stdcall put_PageSize(
	    long pl) = 0;
	virtual HRESULT __stdcall get_Sort(
	    BSTR * Criteria) = 0;
	virtual HRESULT __stdcall put_Sort(
	    BSTR Criteria) = 0;
	virtual HRESULT __stdcall get_Status(
	    long * pl) = 0;
	virtual HRESULT __stdcall get_State(
	    long * plObjState) = 0;
	virtual HRESULT __stdcall raw__xClone(
	    struct _Recordset ** ppvObject) = 0;
	virtual HRESULT __stdcall raw_UpdateBatch(
	    enum AffectEnum AffectRecords) = 0;
	virtual HRESULT __stdcall raw_CancelBatch(
	    enum AffectEnum AffectRecords) = 0;
	virtual HRESULT __stdcall get_CursorLocation(
	    enum CursorLocationEnum * plCursorLoc) = 0;
	virtual HRESULT __stdcall put_CursorLocation(
	    enum CursorLocationEnum plCursorLoc) = 0;
	virtual HRESULT __stdcall raw_NextRecordset(
	    VARIANT * RecordsAffected,
	    struct _Recordset ** ppiRs) = 0;
	virtual HRESULT __stdcall raw_Supports(
	    enum CursorOptionEnum CursorOptions,
	    VARIANT_BOOL * pb) = 0;
	virtual HRESULT __stdcall get_Collect(
	    VARIANT Index,
	    VARIANT * pvar) = 0;
	virtual HRESULT __stdcall put_Collect(
	    VARIANT Index,
	    VARIANT pvar) = 0;
	virtual HRESULT __stdcall get_MarshalOptions(
	    enum MarshalOptionsEnum * peMarshal) = 0;
	virtual HRESULT __stdcall put_MarshalOptions(
	    enum MarshalOptionsEnum peMarshal) = 0;
	virtual HRESULT __stdcall raw_Find(
	    BSTR Criteria,
	    ADO_LONGPTR SkipRecords,
	    enum SearchDirectionEnum SearchDirection,
	    VARIANT Start = vtMissing) = 0;
};
struct Recordset20: public Recordset15
{
	HRESULT Cancel();
	IUnknownPtr GetDataSource();
	void PutRefDataSource(
	    IUnknown * ppunkDataSource);
	HRESULT _xSave(
	    _bstr_t FileName,
	    enum PersistFormatEnum PersistFormat);
	IDispatchPtr GetActiveCommand();
	void PutStayInSync(
	    VARIANT_BOOL pbStayInSync);
	VARIANT_BOOL GetStayInSync();
	_bstr_t GetString(
	    enum StringFormatEnum StringFormat,
	    long NumRows,
	    _bstr_t ColumnDelimeter,
	    _bstr_t RowDelimeter,
	    _bstr_t NullExpr);
	_bstr_t GetDataMember();
	void PutDataMember(
	    _bstr_t pbstrDataMember);
	enum CompareEnum CompareBookmarks(
	    const _variant_t & Bookmark1,
	    const _variant_t & Bookmark2);
	_RecordsetPtr Clone(
	    enum LockTypeEnum LockType);
	HRESULT Resync(
	    enum AffectEnum AffectRecords,
	    enum ResyncEnum ResyncValues);
	virtual HRESULT __stdcall raw_Cancel() = 0;
	virtual HRESULT __stdcall get_DataSource(
	    IUnknown ** ppunkDataSource) = 0;
	virtual HRESULT __stdcall putref_DataSource(
	    IUnknown * ppunkDataSource) = 0;
	virtual HRESULT __stdcall raw__xSave(
	    BSTR FileName,
	    enum PersistFormatEnum PersistFormat) = 0;
	virtual HRESULT __stdcall get_ActiveCommand(
	    IDispatch ** ppCmd) = 0;
	virtual HRESULT __stdcall put_StayInSync(
	    VARIANT_BOOL pbStayInSync) = 0;
	virtual HRESULT __stdcall get_StayInSync(
	    VARIANT_BOOL * pbStayInSync) = 0;
	virtual HRESULT __stdcall raw_GetString(
	    enum StringFormatEnum StringFormat,
	    long NumRows,
	    BSTR ColumnDelimeter,
	    BSTR RowDelimeter,
	    BSTR NullExpr,
	    BSTR * pRetString) = 0;
	virtual HRESULT __stdcall get_DataMember(
	    BSTR * pbstrDataMember) = 0;
	virtual HRESULT __stdcall put_DataMember(
	    BSTR pbstrDataMember) = 0;
	virtual HRESULT __stdcall raw_CompareBookmarks(
	    VARIANT Bookmark1,
	    VARIANT Bookmark2,
	    enum CompareEnum * pCompare) = 0;
	virtual HRESULT __stdcall raw_Clone(
	    enum LockTypeEnum LockType,
	    struct _Recordset ** ppvObject) = 0;
	virtual HRESULT __stdcall raw_Resync(
	    enum AffectEnum AffectRecords,
	    enum ResyncEnum ResyncValues) = 0;
};
struct Recordset21: public Recordset20
{
	HRESULT Seek(
	    const _variant_t & KeyValues,
	    enum SeekEnum SeekOption);
	void PutIndex(
	    _bstr_t pbstrIndex);
	_bstr_t GetIndex();
	virtual HRESULT __stdcall raw_Seek(
	    VARIANT KeyValues,
	    enum SeekEnum SeekOption) = 0;
	virtual HRESULT __stdcall put_Index(
	    BSTR pbstrIndex) = 0;
	virtual HRESULT __stdcall get_Index(
	    BSTR * pbstrIndex) = 0;
};
struct _Recordset: public Recordset21
{
	HRESULT Save(
	    const _variant_t & Destination,
	    enum PersistFormatEnum PersistFormat);
	virtual HRESULT __stdcall raw_Save(
	    VARIANT Destination,
	    enum PersistFormatEnum PersistFormat) = 0;
};
struct Fields15: public _Collection
{
	FieldPtr GetItem(
	    const _variant_t & Index);
	virtual HRESULT __stdcall get_Item(
	    VARIANT Index,
	    struct Field ** ppvObject) = 0;
};
struct Fields20: public Fields15
{
	HRESULT _Append(
	    _bstr_t Name,
	    enum DataTypeEnum Type,
	    ADO_LONGPTR DefinedSize,
	    enum FieldAttributeEnum Attrib);
	HRESULT Delete(
	    const _variant_t & Index);
	virtual HRESULT __stdcall raw__Append(
	    BSTR Name,
	    enum DataTypeEnum Type,
	    ADO_LONGPTR DefinedSize,
	    enum FieldAttributeEnum Attrib) = 0;
	virtual HRESULT __stdcall raw_Delete(
	    VARIANT Index) = 0;
};
struct Fields: public Fields20
{
	HRESULT Append(
	    _bstr_t Name,
	    enum DataTypeEnum Type,
	    ADO_LONGPTR DefinedSize,
	    enum FieldAttributeEnum Attrib,
	    const _variant_t & FieldValue = vtMissing);
	HRESULT Update();
	HRESULT Resync(
	    enum ResyncEnum ResyncValues);
	HRESULT CancelUpdate();
	virtual HRESULT __stdcall raw_Append(
	    BSTR Name,
	    enum DataTypeEnum Type,
	    ADO_LONGPTR DefinedSize,
	    enum FieldAttributeEnum Attrib,
	    VARIANT FieldValue = vtMissing) = 0;
	virtual HRESULT __stdcall raw_Update() = 0;
	virtual HRESULT __stdcall raw_Resync(
	    enum ResyncEnum ResyncValues) = 0;
	virtual HRESULT __stdcall raw_CancelUpdate() = 0;
};
struct Field20: public _ADO
{
	ADO_LONGPTR GetActualSize();
	long GetAttributes();
	ADO_LONGPTR GetDefinedSize();
	_bstr_t GetName();
	enum DataTypeEnum GetType();
	_variant_t GetValue();
	void PutValue(
	    const _variant_t & pvar);
	unsigned char GetPrecision();
	unsigned char GetNumericScale();
	HRESULT AppendChunk(
	    const _variant_t & Data);
	_variant_t GetChunk(
	    long Length);
	_variant_t GetOriginalValue();
	_variant_t GetUnderlyingValue();
	IUnknownPtr GetDataFormat();
	void PutRefDataFormat(
	    IUnknown * ppiDF);
	void PutPrecision(
	    unsigned char pbPrecision);
	void PutNumericScale(
	    unsigned char pbNumericScale);
	void PutType(
	    enum DataTypeEnum pDataType);
	void PutDefinedSize(
	    ADO_LONGPTR pl);
	void PutAttributes(
	    long pl);
	virtual HRESULT __stdcall get_ActualSize(
	    ADO_LONGPTR * pl) = 0;
	virtual HRESULT __stdcall get_Attributes(
	    long * pl) = 0;
	virtual HRESULT __stdcall get_DefinedSize(
	    ADO_LONGPTR * pl) = 0;
	virtual HRESULT __stdcall get_Name(
	    BSTR * pbstr) = 0;
	virtual HRESULT __stdcall get_Type(
	    enum DataTypeEnum * pDataType) = 0;
	virtual HRESULT __stdcall get_Value(
	    VARIANT * pvar) = 0;
	virtual HRESULT __stdcall put_Value(
	    VARIANT pvar) = 0;
	virtual HRESULT __stdcall get_Precision(
	    unsigned char * pbPrecision) = 0;
	virtual HRESULT __stdcall get_NumericScale(
	    unsigned char * pbNumericScale) = 0;
	virtual HRESULT __stdcall raw_AppendChunk(
	    VARIANT Data) = 0;
	virtual HRESULT __stdcall raw_GetChunk(
	    long Length,
	    VARIANT * pvar) = 0;
	virtual HRESULT __stdcall get_OriginalValue(
	    VARIANT * pvar) = 0;
	virtual HRESULT __stdcall get_UnderlyingValue(
	    VARIANT * pvar) = 0;
	virtual HRESULT __stdcall get_DataFormat(
	    IUnknown ** ppiDF) = 0;
	virtual HRESULT __stdcall putref_DataFormat(
	    IUnknown * ppiDF) = 0;
	virtual HRESULT __stdcall put_Precision(
	    unsigned char pbPrecision) = 0;
	virtual HRESULT __stdcall put_NumericScale(
	    unsigned char pbNumericScale) = 0;
	virtual HRESULT __stdcall put_Type(
	    enum DataTypeEnum pDataType) = 0;
	virtual HRESULT __stdcall put_DefinedSize(
	    ADO_LONGPTR pl) = 0;
	virtual HRESULT __stdcall put_Attributes(
	    long pl) = 0;
};
struct Field: public Field20
{
	long GetStatus();
	virtual HRESULT __stdcall get_Status(
	    long * pFStatus) = 0;
};
struct _Parameter: public _ADO
{
	_bstr_t GetName();
	void PutName(
	    _bstr_t pbstr);
	_variant_t GetValue();
	void PutValue(
	    const _variant_t & pvar);
	enum DataTypeEnum GetType();
	void PutType(
	    enum DataTypeEnum psDataType);
	void PutDirection(
	    enum ParameterDirectionEnum plParmDirection);
	enum ParameterDirectionEnum GetDirection();
	void PutPrecision(
	    unsigned char pbPrecision);
	unsigned char GetPrecision();
	void PutNumericScale(
	    unsigned char pbScale);
	unsigned char GetNumericScale();
	void PutSize(
	    ADO_LONGPTR pl);
	ADO_LONGPTR GetSize();
	HRESULT AppendChunk(
	    const _variant_t & Val);
	long GetAttributes();
	void PutAttributes(
	    long plParmAttribs);
	virtual HRESULT __stdcall get_Name(
	    BSTR * pbstr) = 0;
	virtual HRESULT __stdcall put_Name(
	    BSTR pbstr) = 0;
	virtual HRESULT __stdcall get_Value(
	    VARIANT * pvar) = 0;
	virtual HRESULT __stdcall put_Value(
	    VARIANT pvar) = 0;
	virtual HRESULT __stdcall get_Type(
	    enum DataTypeEnum * psDataType) = 0;
	virtual HRESULT __stdcall put_Type(
	    enum DataTypeEnum psDataType) = 0;
	virtual HRESULT __stdcall put_Direction(
	    enum ParameterDirectionEnum plParmDirection) = 0;
	virtual HRESULT __stdcall get_Direction(
	    enum ParameterDirectionEnum * plParmDirection) = 0;
	virtual HRESULT __stdcall put_Precision(
	    unsigned char pbPrecision) = 0;
	virtual HRESULT __stdcall get_Precision(
	    unsigned char * pbPrecision) = 0;
	virtual HRESULT __stdcall put_NumericScale(
	    unsigned char pbScale) = 0;
	virtual HRESULT __stdcall get_NumericScale(
	    unsigned char * pbScale) = 0;
	virtual HRESULT __stdcall put_Size(
	    ADO_LONGPTR pl) = 0;
	virtual HRESULT __stdcall get_Size(
	    ADO_LONGPTR * pl) = 0;
	virtual HRESULT __stdcall raw_AppendChunk(
	    VARIANT Val) = 0;
	virtual HRESULT __stdcall get_Attributes(
	    long * plParmAttribs) = 0;
	virtual HRESULT __stdcall put_Attributes(
	    long plParmAttribs) = 0;
};
struct Parameters: public _DynaCollection
{
	_ParameterPtr GetItem(
	    const _variant_t & Index);
	virtual HRESULT __stdcall get_Item(
	    VARIANT Index,
	    struct _Parameter ** ppvObject) = 0;
};
struct Command25: public Command15
{
	long GetState();
	HRESULT Cancel();
	virtual HRESULT __stdcall get_State(
	    long * plObjState) = 0;
	virtual HRESULT __stdcall raw_Cancel() = 0;
};
struct _Command: public Command25
{
	void PutRefCommandStream(
	    IUnknown * pvStream);
	_variant_t GetCommandStream();
	void PutDialect(
	    _bstr_t pbstrDialect);
	_bstr_t GetDialect();
	void PutNamedParameters(
	    VARIANT_BOOL pfNamedParameters);
	VARIANT_BOOL GetNamedParameters();
	virtual HRESULT __stdcall putref_CommandStream(
	    IUnknown * pvStream) = 0;
	virtual HRESULT __stdcall get_CommandStream(
	    VARIANT * pvStream) = 0;
	virtual HRESULT __stdcall put_Dialect(
	    BSTR pbstrDialect) = 0;
	virtual HRESULT __stdcall get_Dialect(
	    BSTR * pbstrDialect) = 0;
	virtual HRESULT __stdcall put_NamedParameters(
	    VARIANT_BOOL pfNamedParameters) = 0;
	virtual HRESULT __stdcall get_NamedParameters(
	    VARIANT_BOOL * pfNamedParameters) = 0;
};
struct ConnectionEventsVt: public IUnknown
{
	HRESULT InfoMessage(
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Connection * pConnection);
	HRESULT BeginTransComplete(
	    long TransactionLevel,
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Connection * pConnection);
	HRESULT CommitTransComplete(
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Connection * pConnection);
	HRESULT RollbackTransComplete(
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Connection * pConnection);
	HRESULT WillExecute(
	    BSTR * Source,
	    enum CursorTypeEnum * CursorType,
	    enum LockTypeEnum * LockType,
	    long * Options,
	    enum EventStatusEnum * adStatus,
	    struct _Command * pCommand,
	    struct _Recordset * pRecordset,
	    struct _Connection * pConnection);
	HRESULT ExecuteComplete(
	    long RecordsAffected,
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Command * pCommand,
	    struct _Recordset * pRecordset,
	    struct _Connection * pConnection);
	HRESULT WillConnect(
	    BSTR * ConnectionString,
	    BSTR * UserID,
	    BSTR * Password,
	    long * Options,
	    enum EventStatusEnum * adStatus,
	    struct _Connection * pConnection);
	HRESULT ConnectComplete(
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Connection * pConnection);
	HRESULT Disconnect(
	    enum EventStatusEnum * adStatus,
	    struct _Connection * pConnection);
	virtual HRESULT __stdcall raw_InfoMessage(
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Connection * pConnection) = 0;
	virtual HRESULT __stdcall raw_BeginTransComplete(
	    long TransactionLevel,
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Connection * pConnection) = 0;
	virtual HRESULT __stdcall raw_CommitTransComplete(
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Connection * pConnection) = 0;
	virtual HRESULT __stdcall raw_RollbackTransComplete(
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Connection * pConnection) = 0;
	virtual HRESULT __stdcall raw_WillExecute(
	    BSTR * Source,
	    enum CursorTypeEnum * CursorType,
	    enum LockTypeEnum * LockType,
	    long * Options,
	    enum EventStatusEnum * adStatus,
	    struct _Command * pCommand,
	    struct _Recordset * pRecordset,
	    struct _Connection * pConnection) = 0;
	virtual HRESULT __stdcall raw_ExecuteComplete(
	    long RecordsAffected,
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Command * pCommand,
	    struct _Recordset * pRecordset,
	    struct _Connection * pConnection) = 0;
	virtual HRESULT __stdcall raw_WillConnect(
	    BSTR * ConnectionString,
	    BSTR * UserID,
	    BSTR * Password,
	    long * Options,
	    enum EventStatusEnum * adStatus,
	    struct _Connection * pConnection) = 0;
	virtual HRESULT __stdcall raw_ConnectComplete(
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Connection * pConnection) = 0;
	virtual HRESULT __stdcall raw_Disconnect(
	    enum EventStatusEnum * adStatus,
	    struct _Connection * pConnection) = 0;
};
struct RecordsetEventsVt: public IUnknown
{
	HRESULT WillChangeField(
	    long cFields,
	    const _variant_t & Fields,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset);
	HRESULT FieldChangeComplete(
	    long cFields,
	    const _variant_t & Fields,
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset);
	HRESULT WillChangeRecord(
	    enum EventReasonEnum adReason,
	    long cRecords,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset);
	HRESULT RecordChangeComplete(
	    enum EventReasonEnum adReason,
	    long cRecords,
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset);
	HRESULT WillChangeRecordset(
	    enum EventReasonEnum adReason,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset);
	HRESULT RecordsetChangeComplete(
	    enum EventReasonEnum adReason,
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset);
	HRESULT WillMove(
	    enum EventReasonEnum adReason,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset);
	HRESULT MoveComplete(
	    enum EventReasonEnum adReason,
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset);
	HRESULT EndOfRecordset(
	    VARIANT_BOOL * fMoreData,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset);
	HRESULT FetchProgress(
	    long Progress,
	    long MaxProgress,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset);
	HRESULT FetchComplete(
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset);
	virtual HRESULT __stdcall raw_WillChangeField(
	    long cFields,
	    VARIANT Fields,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset) = 0;
	virtual HRESULT __stdcall raw_FieldChangeComplete(
	    long cFields,
	    VARIANT Fields,
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset) = 0;
	virtual HRESULT __stdcall raw_WillChangeRecord(
	    enum EventReasonEnum adReason,
	    long cRecords,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset) = 0;
	virtual HRESULT __stdcall raw_RecordChangeComplete(
	    enum EventReasonEnum adReason,
	    long cRecords,
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset) = 0;
	virtual HRESULT __stdcall raw_WillChangeRecordset(
	    enum EventReasonEnum adReason,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset) = 0;
	virtual HRESULT __stdcall raw_RecordsetChangeComplete(
	    enum EventReasonEnum adReason,
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset) = 0;
	virtual HRESULT __stdcall raw_WillMove(
	    enum EventReasonEnum adReason,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset) = 0;
	virtual HRESULT __stdcall raw_MoveComplete(
	    enum EventReasonEnum adReason,
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset) = 0;
	virtual HRESULT __stdcall raw_EndOfRecordset(
	    VARIANT_BOOL * fMoreData,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset) = 0;
	virtual HRESULT __stdcall raw_FetchProgress(
	    long Progress,
	    long MaxProgress,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset) = 0;
	virtual HRESULT __stdcall raw_FetchComplete(
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset) = 0;
};
struct ConnectionEvents: public IDispatch
{
	// Methods:
	HRESULT InfoMessage(
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Connection * pConnection);
	HRESULT BeginTransComplete(
	    long TransactionLevel,
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Connection * pConnection);
	HRESULT CommitTransComplete(
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Connection * pConnection);
	HRESULT RollbackTransComplete(
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Connection * pConnection);
	HRESULT WillExecute(
	    BSTR * Source,
	    enum CursorTypeEnum * CursorType,
	    enum LockTypeEnum * LockType,
	    long * Options,
	    enum EventStatusEnum * adStatus,
	    struct _Command * pCommand,
	    struct _Recordset * pRecordset,
	    struct _Connection * pConnection);
	HRESULT ExecuteComplete(
	    long RecordsAffected,
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Command * pCommand,
	    struct _Recordset * pRecordset,
	    struct _Connection * pConnection);
	HRESULT WillConnect(
	    BSTR * ConnectionString,
	    BSTR * UserID,
	    BSTR * Password,
	    long * Options,
	    enum EventStatusEnum * adStatus,
	    struct _Connection * pConnection);
	HRESULT ConnectComplete(
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Connection * pConnection);
	HRESULT Disconnect(
	    enum EventStatusEnum * adStatus,
	    struct _Connection * pConnection);
};
struct RecordsetEvents: public IDispatch
{
	// Methods:
	HRESULT WillChangeField(
	    long cFields,
	    const _variant_t & Fields,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset);
	HRESULT FieldChangeComplete(
	    long cFields,
	    const _variant_t & Fields,
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset);
	HRESULT WillChangeRecord(
	    enum EventReasonEnum adReason,
	    long cRecords,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset);
	HRESULT RecordChangeComplete(
	    enum EventReasonEnum adReason,
	    long cRecords,
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset);
	HRESULT WillChangeRecordset(
	    enum EventReasonEnum adReason,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset);
	HRESULT RecordsetChangeComplete(
	    enum EventReasonEnum adReason,
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset);
	HRESULT WillMove(
	    enum EventReasonEnum adReason,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset);
	HRESULT MoveComplete(
	    enum EventReasonEnum adReason,
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset);
	HRESULT EndOfRecordset(
	    VARIANT_BOOL * fMoreData,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset);
	HRESULT FetchProgress(
	    long Progress,
	    long MaxProgress,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset);
	HRESULT FetchComplete(
	    struct Error * pError,
	    enum EventStatusEnum * adStatus,
	    struct _Recordset * pRecordset);
};
struct ADOConnectionConstruction15: public IUnknown
{
	IUnknownPtr GetDSO();
	IUnknownPtr GetSession();
	HRESULT WrapDSOandSession(
	    IUnknown * pDSO,
	    IUnknown * pSession);
	virtual HRESULT __stdcall get_DSO(
	    IUnknown ** ppDSO) = 0;
	virtual HRESULT __stdcall get_Session(
	    IUnknown ** ppSession) = 0;
	virtual HRESULT __stdcall raw_WrapDSOandSession(
	    IUnknown * pDSO,
	    IUnknown * pSession) = 0;
};
struct ADOConnectionConstruction: public ADOConnectionConstruction15
{};
struct Connection;
// [ default ] interface _Connection
// [ default, source ] dispinterface ConnectionEvents
struct _Record: public _ADO
{
	_variant_t GetActiveConnection();
	void PutActiveConnection(
	    _bstr_t pvar);
	void PutRefActiveConnection(
	    struct _Connection * pvar);
	enum ObjectStateEnum GetState();
	_variant_t GetSource();
	void PutSource(
	    _bstr_t pvar);
	void PutRefSource(
	    IDispatch * pvar);
	enum ConnectModeEnum GetMode();
	void PutMode(
	    enum ConnectModeEnum pMode);
	_bstr_t GetParentURL();
	_bstr_t MoveRecord(
	    _bstr_t Source,
	    _bstr_t Destination,
	    _bstr_t UserName,
	    _bstr_t Password,
	    enum MoveRecordOptionsEnum Options,
	    VARIANT_BOOL Async);
	_bstr_t CopyRecord(
	    _bstr_t Source,
	    _bstr_t Destination,
	    _bstr_t UserName,
	    _bstr_t Password,
	    enum CopyRecordOptionsEnum Options,
	    VARIANT_BOOL Async);
	HRESULT DeleteRecord(
	    _bstr_t Source,
	    VARIANT_BOOL Async);
	HRESULT Open(
	    const _variant_t & Source,
	    const _variant_t & ActiveConnection,
	    enum ConnectModeEnum Mode,
	    enum RecordCreateOptionsEnum CreateOptions,
	    enum RecordOpenOptionsEnum Options,
	    _bstr_t UserName,
	    _bstr_t Password);
	HRESULT Close();
	FieldsPtr GetFields();
	enum RecordTypeEnum GetRecordType();
	_RecordsetPtr GetChildren();
	HRESULT Cancel();
	virtual HRESULT __stdcall get_ActiveConnection(
	    VARIANT * pvar) = 0;
	virtual HRESULT __stdcall put_ActiveConnection(
	    BSTR pvar) = 0;
	virtual HRESULT __stdcall putref_ActiveConnection(
	    struct _Connection * pvar) = 0;
	virtual HRESULT __stdcall get_State(
	    enum ObjectStateEnum * pState) = 0;
	virtual HRESULT __stdcall get_Source(
	    VARIANT * pvar) = 0;
	virtual HRESULT __stdcall put_Source(
	    BSTR pvar) = 0;
	virtual HRESULT __stdcall putref_Source(
	    IDispatch * pvar) = 0;
	virtual HRESULT __stdcall get_Mode(
	    enum ConnectModeEnum * pMode) = 0;
	virtual HRESULT __stdcall put_Mode(
	    enum ConnectModeEnum pMode) = 0;
	virtual HRESULT __stdcall get_ParentURL(
	    BSTR * pbstrParentURL) = 0;
	virtual HRESULT __stdcall raw_MoveRecord(
	    BSTR Source,
	    BSTR Destination,
	    BSTR UserName,
	    BSTR Password,
	    enum MoveRecordOptionsEnum Options,
	    VARIANT_BOOL Async,
	    BSTR * pbstrNewURL) = 0;
	virtual HRESULT __stdcall raw_CopyRecord(
	    BSTR Source,
	    BSTR Destination,
	    BSTR UserName,
	    BSTR Password,
	    enum CopyRecordOptionsEnum Options,
	    VARIANT_BOOL Async,
	    BSTR * pbstrNewURL) = 0;
	virtual HRESULT __stdcall raw_DeleteRecord(
	    BSTR Source,
	    VARIANT_BOOL Async) = 0;
	virtual HRESULT __stdcall raw_Open(
	    VARIANT Source,
	    VARIANT ActiveConnection,
	    enum ConnectModeEnum Mode,
	    enum RecordCreateOptionsEnum CreateOptions,
	    enum RecordOpenOptionsEnum Options,
	    BSTR UserName,
	    BSTR Password) = 0;
	virtual HRESULT __stdcall raw_Close() = 0;
	virtual HRESULT __stdcall get_Fields(
	    struct Fields ** ppFlds) = 0;
	virtual HRESULT __stdcall get_RecordType(
	    enum RecordTypeEnum * ptype) = 0;
	virtual HRESULT __stdcall raw_GetChildren(
	    struct _Recordset ** pprset) = 0;
	virtual HRESULT __stdcall raw_Cancel() = 0;
};
struct Record;
// [ default ] interface _Record
struct _Stream: public IDispatch
{
	ADO_LONGPTR GetSize();
	VARIANT_BOOL GetEOS();
	ADO_LONGPTR GetPosition();
	void PutPosition(
	    ADO_LONGPTR pPos);
	enum StreamTypeEnum GetType();
	void PutType(
	    enum StreamTypeEnum ptype);
	enum LineSeparatorEnum GetLineSeparator();
	void PutLineSeparator(
	    enum LineSeparatorEnum pLS);
	enum ObjectStateEnum GetState();
	enum ConnectModeEnum GetMode();
	void PutMode(
	    enum ConnectModeEnum pMode);
	_bstr_t GetCharset();
	void PutCharset(
	    _bstr_t pbstrCharset);
	_variant_t Read(
	    long NumBytes);
	HRESULT Open(
	    const _variant_t & Source,
	    enum ConnectModeEnum Mode,
	    enum StreamOpenOptionsEnum Options,
	    _bstr_t UserName,
	    _bstr_t Password);
	HRESULT Close();
	HRESULT SkipLine();
	HRESULT Write(
	    const _variant_t & Buffer);
	HRESULT SetEOS();
	HRESULT CopyTo(
	    struct _Stream * DestStream,
	    ADO_LONGPTR CharNumber);
	HRESULT Flush();
	HRESULT SaveToFile(
	    _bstr_t FileName,
	    enum SaveOptionsEnum Options);
	HRESULT LoadFromFile(
	    _bstr_t FileName);
	_bstr_t ReadText(
	    long NumChars);
	HRESULT WriteText(
	    _bstr_t Data,
	    enum StreamWriteEnum Options);
	HRESULT Cancel();
	virtual HRESULT __stdcall get_Size(
	    ADO_LONGPTR * pSize) = 0;
	virtual HRESULT __stdcall get_EOS(
	    VARIANT_BOOL * pEOS) = 0;
	virtual HRESULT __stdcall get_Position(
	    ADO_LONGPTR * pPos) = 0;
	virtual HRESULT __stdcall put_Position(
	    ADO_LONGPTR pPos) = 0;
	virtual HRESULT __stdcall get_Type(
	    enum StreamTypeEnum * ptype) = 0;
	virtual HRESULT __stdcall put_Type(
	    enum StreamTypeEnum ptype) = 0;
	virtual HRESULT __stdcall get_LineSeparator(
	    enum LineSeparatorEnum * pLS) = 0;
	virtual HRESULT __stdcall put_LineSeparator(
	    enum LineSeparatorEnum pLS) = 0;
	virtual HRESULT __stdcall get_State(
	    enum ObjectStateEnum * pState) = 0;
	virtual HRESULT __stdcall get_Mode(
	    enum ConnectModeEnum * pMode) = 0;
	virtual HRESULT __stdcall put_Mode(
	    enum ConnectModeEnum pMode) = 0;
	virtual HRESULT __stdcall get_Charset(
	    BSTR * pbstrCharset) = 0;
	virtual HRESULT __stdcall put_Charset(
	    BSTR pbstrCharset) = 0;
	virtual HRESULT __stdcall raw_Read(
	    long NumBytes,
	    VARIANT * pval) = 0;
	virtual HRESULT __stdcall raw_Open(
	    VARIANT Source,
	    enum ConnectModeEnum Mode,
	    enum StreamOpenOptionsEnum Options,
	    BSTR UserName,
	    BSTR Password) = 0;
	virtual HRESULT __stdcall raw_Close() = 0;
	virtual HRESULT __stdcall raw_SkipLine() = 0;
	virtual HRESULT __stdcall raw_Write(
	    VARIANT Buffer) = 0;
	virtual HRESULT __stdcall raw_SetEOS() = 0;
	virtual HRESULT __stdcall raw_CopyTo(
	    struct _Stream * DestStream,
	    ADO_LONGPTR CharNumber) = 0;
	virtual HRESULT __stdcall raw_Flush() = 0;
	virtual HRESULT __stdcall raw_SaveToFile(
	    BSTR FileName,
	    enum SaveOptionsEnum Options) = 0;
	virtual HRESULT __stdcall raw_LoadFromFile(
	    BSTR FileName) = 0;
	virtual HRESULT __stdcall raw_ReadText(
	    long NumChars,
	    BSTR * pbstr) = 0;
	virtual HRESULT __stdcall raw_WriteText(
	    BSTR Data,
	    enum StreamWriteEnum Options) = 0;
	virtual HRESULT __stdcall raw_Cancel() = 0;
};
struct Stream;
// [ default ] interface _Stream
struct ADORecordConstruction: public IDispatch
{
	IUnknownPtr GetRow();
	void PutRow(
	    IUnknown * ppRow);
	void PutParentRow(
	    IUnknown * _arg1);
	virtual HRESULT __stdcall get_Row(
	    IUnknown ** ppRow) = 0;
	virtual HRESULT __stdcall put_Row(
	    IUnknown * ppRow) = 0;
	virtual HRESULT __stdcall put_ParentRow(
	    IUnknown * _arg1) = 0;
};
struct ADOStreamConstruction: public IDispatch
{
	IUnknownPtr GetStream();
	void PutStream(
	    IUnknown * ppStm);
	virtual HRESULT __stdcall get_Stream(
	    IUnknown ** ppStm) = 0;
	virtual HRESULT __stdcall put_Stream(
	    IUnknown * ppStm) = 0;
};
struct ADOCommandConstruction: public IUnknown
{
	IUnknownPtr GetOLEDBCommand();
	void PutOLEDBCommand(
	    IUnknown * ppOLEDBCommand);
	virtual HRESULT __stdcall get_OLEDBCommand(
	    IUnknown ** ppOLEDBCommand) = 0;
	virtual HRESULT __stdcall put_OLEDBCommand(
	    IUnknown * ppOLEDBCommand) = 0;
};
struct Command;
// [ default ] interface _Command
struct Recordset;
// [ default ] interface _Recordset
// [ default, source ] dispinterface RecordsetEvents
struct ADORecordsetConstruction: public IDispatch
{
	IUnknownPtr GetRowset();
	void PutRowset(
	    IUnknown * ppRowset);
	ADO_LONGPTR GetChapter();
	void PutChapter(
	    ADO_LONGPTR plChapter);
	IUnknownPtr GetRowPosition();
	void PutRowPosition(
	    IUnknown * ppRowPos);
	virtual HRESULT __stdcall get_Rowset(
	    IUnknown ** ppRowset) = 0;
	virtual HRESULT __stdcall put_Rowset(
	    IUnknown * ppRowset) = 0;
	virtual HRESULT __stdcall get_Chapter(
	    ADO_LONGPTR * plChapter) = 0;
	virtual HRESULT __stdcall put_Chapter(
	    ADO_LONGPTR plChapter) = 0;
	virtual HRESULT __stdcall get_RowPosition(
	    IUnknown ** ppRowPos) = 0;
	virtual HRESULT __stdcall put_RowPosition(
	    IUnknown * ppRowPos) = 0;
};
struct Field15: public _ADO
{
	ADO_LONGPTR GetActualSize();
	long GetAttributes();
	ADO_LONGPTR GetDefinedSize();
	_bstr_t GetName();
	enum DataTypeEnum GetType();
	_variant_t GetValue();
	void PutValue(
	    const _variant_t & pvar);
	unsigned char GetPrecision();
	unsigned char GetNumericScale();
	HRESULT AppendChunk(
	    const _variant_t & Data);
	_variant_t GetChunk(
	    long Length);
	_variant_t GetOriginalValue();
	_variant_t GetUnderlyingValue();
	virtual HRESULT __stdcall get_ActualSize(
	    ADO_LONGPTR * pl) = 0;
	virtual HRESULT __stdcall get_Attributes(
	    long * pl) = 0;
	virtual HRESULT __stdcall get_DefinedSize(
	    ADO_LONGPTR * pl) = 0;
	virtual HRESULT __stdcall get_Name(
	    BSTR * pbstr) = 0;
	virtual HRESULT __stdcall get_Type(
	    enum DataTypeEnum * pDataType) = 0;
	virtual HRESULT __stdcall get_Value(
	    VARIANT * pvar) = 0;
	virtual HRESULT __stdcall put_Value(
	    VARIANT pvar) = 0;
	virtual HRESULT __stdcall get_Precision(
	    unsigned char * pbPrecision) = 0;
	virtual HRESULT __stdcall get_NumericScale(
	    unsigned char * pbNumericScale) = 0;
	virtual HRESULT __stdcall raw_AppendChunk(
	    VARIANT Data) = 0;
	virtual HRESULT __stdcall raw_GetChunk(
	    long Length,
	    VARIANT * pvar) = 0;
	virtual HRESULT __stdcall get_OriginalValue(
	    VARIANT * pvar) = 0;
	virtual HRESULT __stdcall get_UnderlyingValue(
	    VARIANT * pvar) = 0;
};
struct Parameter;
#include "msado15_tli.h"
} // namespace ADODB
#include <poppack.h>
#endif
